home *** CD-ROM | disk | FTP | other *** search
/ Aminet 15 / Aminet 15 - Nov 1996.iso / Aminet / dev / misc / libx11.lha / libX11 / x11events.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-09-22  |  41.0 KB  |  1,558 lines
  1. /* Copyright (c) 1996 by Terje Pedersen.  All Rights Reserved   */
  2. /*                                                              */
  3. /* By using this code you will agree to these terms:            */
  4. /*                                                              */
  5. /* 1. You may not use this code for profit in any way or form   */
  6. /*    unless an agreement with the author has been reached.     */
  7. /*                                                              */
  8. /* 2. The author is not responsible for any damages caused by   */
  9. /*    the use of this code.                                     */
  10. /*                                                              */
  11. /* 3. All modifications are to be released to the public.       */
  12. /*                                                              */
  13. /* Thats it! Have fun!                                          */
  14. /* TP                                                           */
  15. /*                                                              */
  16.  
  17. /***
  18.    NAME
  19.      events
  20.    PURPOSE
  21.      add eventhandling to libX11
  22.    NOTES
  23.      
  24.    HISTORY
  25.      Terje Pedersen - Oct 23, 1994: Created.
  26. ***/
  27.  
  28. #include <intuition/intuition.h>
  29. #include <intuition/intuitionbase.h>
  30.  
  31. #include <graphics/gfx.h>
  32. #include <graphics/gfxbase.h>
  33. #include <graphics/gfxmacros.h>
  34. #include <graphics/displayinfo.h>
  35. #include <devices/timer.h>
  36. #include <devices/keymap.h>
  37. #include <devices/inputevent.h>
  38.  
  39. #include <proto/intuition.h>
  40. #include <proto/graphics.h>
  41. #include <proto/gadtools.h>
  42. #include <proto/layers.h>
  43. #include <proto/keymap.h>
  44.  
  45. #include <dos.h>
  46. #include <signal.h>
  47. #include <stdlib.h>
  48. #include <time.h>
  49. #include <stdio.h>
  50.  
  51. #include "libX11.h"
  52. #define DEBUGXEMUL_WARNING 1
  53.  
  54. #define XLIB_ILLEGAL_ACCESS 1
  55.  
  56. #include <X11/X.h>
  57. #include <X11/Xlib.h>
  58.  
  59. #include <X11/Xutil.h>
  60. #include <X11/Intrinsic.h>
  61. #include <X11/IntrinsicP.h>
  62. #include <X11/CoreP.h>
  63. #define XK_MISCELLANY
  64. #include <X11/keysymdef.h>
  65.  
  66. #include "amigax_proto.h"
  67. #include "amiga_x.h"
  68.  
  69. /* external */
  70. extern Display amigaX_display;
  71. extern Visual  amiga_visual;
  72. extern Screen  amiga_screen[];
  73.  
  74. extern struct Library *KeymapBase;
  75.  
  76. /* internal */
  77.  
  78. EventGlobals_s EG;
  79.  
  80. #define    BUFFERLEN    80
  81. char X11Abuffer[BUFFERLEN];
  82.  
  83. /* internal prototypes */
  84.  
  85. void ALookupKey(struct IntuiMessage *im);
  86. char lookup_key(char *key);
  87. void amiga_get_event(void);
  88. int handle_buttons(XEvent *event,int code);
  89.  
  90. /*
  91. short XKeys[]={
  92.  
  93.           /* 0 */ 0,
  94.       /* 1 */ 0,
  95.       /* 2 */ 0,
  96.       /* 3 */ 0,
  97.       /* 4 */ 0,
  98.       /* 5 */ 0,
  99.       /* 6 */ 0,
  100.       /* 7 */ 0,
  101.       /* 8 */ XK_BackSpace,
  102.       /* 9 */ XK_Tab,
  103.       /* 10 */ XK_Linefeed,
  104.       /* 11 */ XK_Clear,
  105.       /* 12 */ XK_Return,
  106.       /* 13 */ XK_Pause,
  107.       /* 14 */ XK_Scroll_Lock,
  108.       /* 15 */ XK_KP_0,
  109.       /* 16 */ XK_Q,
  110.       /* 17 */ XK_W,
  111.       /* 18 */ XK_E,
  112.       /* 19 */ XK_R,
  113.       /* 20 */ XK_T,
  114.       /* 21 */ XK_Y,
  115.       /* 22 */ XK_U,
  116.       /* 23 */ XK_I,
  117.       /* 24 */ XK_O,
  118.       /* 25 */ XK_P,
  119.       /* 26 */ XK_bracketleft,
  120.       /* 27 */ XK_bracketright,
  121.       /* 28 */ 0,
  122.       /* 29 */ XK_KP_1,
  123.       /* 30 */ XK_KP_2,
  124.       /* 31 */ XK_KP_3,
  125.       /* 32 */ XK_A,
  126.       /* 33 */ XK_S,
  127.       /* 34 */ XK_D,
  128.       /* 35 */ XK_F,
  129.       /* 36 */ XK_G,
  130.       /* 37 */ XK_H,
  131.       /* 38 */ XK_J,
  132.       /* 39 */ XK_K,
  133.       /* 40 */ XK_L,
  134.       /* 41 */ 0,
  135.       /* 42 */ 0,
  136.       /* 43 */ 0,
  137.       /* 44 */ 0,
  138.       /* 45 */ XK_KP_4,
  139.       /* 46 */ XK_KP_5,
  140.       /* 47 */ XK_KP_6,
  141.       /* 48 */ 0,
  142.       /* 49 */ XK_Z,
  143.       /* 50 */ XK_X,
  144.       /* 51 */ XK_C,
  145.       /* 52 */ XK_V,
  146.       /* 53 */ XK_B,
  147.       /* 54 */ XK_N,
  148.       /* 55 */ XK_M,
  149.       /* 56 */ 0,
  150.       /* 57 */ 0,
  151.       /* 58 */ 0,
  152.       /* 59 */ 0,
  153.       /* 60 */ XK_KP_Decimal,
  154.       /* 61 */ XK_KP_7,
  155.       /* 62 */ XK_KP_8,
  156.       /* 63 */ XK_KP_9,
  157.       /* 64 */ 0,
  158.       /* 65 */ 0,
  159.       /* 66 */ 0,
  160.       /* 67 */ XK_KP_Equal,
  161.       /* 68 */ 0,
  162.       /* 69 */ XK_Escape,
  163.       /* 70 */ 0,
  164.       /* 71 */ 0,
  165.       /* 72 */ 0,
  166.       /* 73 */ 0,
  167.       /* 74 */ XK_PK_Substract,
  168.       /* 75 */ 0,
  169.       /* 76 */ 0,
  170.       /* 77 */ 0,
  171.       /* 78 */ 0,
  172.       /* 79 */ 0,
  173.       /* 80 */ XK_F1,
  174.       /* 81 */ XK_F2,
  175.       /* 82 */ XK_F3,
  176.       /* 83 */ XK_F4,
  177.       /* 84 */ XK_F5,
  178.       /* 85 */ XK_F6,
  179.       /* 86 */ XK_F7,
  180.       /* 87 */ XK_F8,
  181.       /* 88 */ XK_F9,
  182.       /* 89 */ XK_F10,
  183.       /* 90 */ XK_KP_F1,
  184.       /* 91 */ XK_KP_F2,
  185.       /* 92 */ XK_KP_Divide,
  186.       /* 93 */ XK_PK_Multiply,
  187.       /* 94 */ XK_PK_Add,
  188.       /* 95 */ 0,
  189.       /* 96 */ XK_Shift_L,
  190.       /* 97 */ XK_Shift_R,
  191.       /* 98 */ XK_Caps_Lock,
  192.       /* 99 */ XK_Control_L,
  193.       /* 100 */ XK_Alt_L,
  194.       /* 101 */ XK_Alt_R,
  195.       /* 102 */ XK_Meta_L,
  196.       /* 103 */ XK_Meta_R,
  197.       /* 104 */ 0,
  198.       /* 105 */ 0,
  199.       /* 106 */ 0,
  200.       /* 107 */ 0,
  201.       /* 108 */ 0,
  202.       /* 109 */ 0,
  203.       /* 110 */ 0,
  204.       /* 111 */ 0,
  205.       /* 112 */ 0,
  206.       /* 113 */ 0,
  207.       /* 114 */ 0,
  208.       /* 115 */ 0,
  209.       /* 116 */ 0,
  210.       /* 117 */ 0,
  211.       /* 118 */ 0,
  212.       /* 119 */ 0,
  213.       /* 120 */ 0,
  214.       /* 121 */ 0,
  215.       /* 122 */ 0,
  216.       /* 123 */ 0,
  217.       /* 124 */ 0,
  218.       /* 125 */ 0,
  219.       /* 126 */ 0,
  220.       /* 127 */ 0,
  221.       /* 128 */ 0,
  222.       /* 129 */ XK_1,
  223.       /* 130 */ XK_2,
  224.       /* 131 */ XK_3,
  225.       /* 132 */ XK_4,
  226.       /* 133 */ XK_5,
  227.       /* 134 */ XK_6,
  228.       /* 135 */ XK_7,
  229.       /* 136 */ XK_8,
  230.       /* 137 */ XK_9,
  231.       /* 138 */ XK_0,
  232.       /* 139 */ XK_minus,
  233.       /* 140 */ XK_equal,
  234.       /* 141 */ XK_backslash,
  235.       /* 142 */ 0,
  236.       /* 143 */ XK_KP_0,
  237.       /* 144 */ XK_Q,
  238.       /* 145 */ XK_W,
  239.       /* 146 */ XK_E,
  240.       /* 147 */ XK_R,
  241.       /* 148 */ XK_T,
  242.       /* 149 */ XK_Y,
  243.       /* 150 */ XK_U,
  244.       /* 151 */ XK_I,
  245.       /* 152 */ XK_O,
  246.       /* 153 */ XK_P,
  247.       /* 154 */ XK_bracketleft,
  248.       /* 155 */ XK_bracketright,
  249.       /* 156 */ 0,
  250.       /* 157 */ XK_End,
  251.       /* 158 */ 0,
  252.       /* 159 */ 0,
  253.       /* 160 */ XK_A,
  254.       /* 161 */ XK_S,
  255.       /* 162 */ XK_D,
  256.       /* 163 */ XK_F,
  257.       /* 164 */ XK_G,
  258.       /* 165 */ XK_H,
  259.       /* 166 */ XK_J,
  260.       /* 167 */ XK_K,
  261.       /* 168 */ XK_L,
  262.       /* 169 */ XK_semicolon,
  263.       /* 170 */ 0,
  264.       /* 171 */ 0,
  265.       /* 172 */ 0,
  266.       /* 173 */ XK_KP_1,
  267.       /* 174 */ XK_KP_2,
  268.       /* 175 */ XK_KP_3,
  269.       /* 176 */ 0,
  270.       /* 177 */ XK_Z,
  271.       /* 178 */ XK_X,
  272.       /* 179 */ XK_C,
  273.       /* 180 */ XK_V,
  274.       /* 181 */ XK_B,
  275.       /* 182 */ XK_N,
  276.       /* 183 */ XK_M,
  277.       /* 184 */ XK_comma,
  278.       /* 185 */ XK_period,
  279.       /* 186 */ XK_slash,
  280.       /* 187 */ XK_comma,
  281.       /* 188 */ XK_KP_Decimal,
  282.       /* 189 */ XK_Home,
  283.       /* 190 */ 0,
  284.       /* 191 */ 0,
  285.       /* 192 */ 0,
  286.       /* 193 */ XK_BackSpace,
  287.       /* 194 */ XK_Tab,
  288.       /* 195 */ XK_KP_Equal,
  289.       /* 196 */ XK_Return,
  290.       /* 197 */ XK_Escape,
  291.       /* 198 */ XK_Delete,
  292.       /* 199 */ 0,
  293.       /* 200 */ 0,
  294.       /* 201 */ 0,
  295.       /* 202 */ XK_PK_Substract,
  296.       /* 203 */ 0,
  297.       /* 204 */ XK_Up,
  298.       /* 205 */ XK_Down,
  299.       /* 206 */ XK_Right,
  300.       /* 207 */ XK_Left,
  301.       /* 208 */ XK_F1,
  302.       /* 209 */ XK_F2,
  303.       /* 210 */ XK_F3,
  304.       /* 211 */ XK_F4,
  305.       /* 212 */ XK_F5,
  306.       /* 213 */ XK_F6,
  307.       /* 214 */ XK_F7,
  308.       /* 215 */ XK_F8,
  309.       /* 216 */ XK_F9,
  310.       /* 217 */ XK_F10,
  311.       /* 218 */ XK_KP_F1,
  312.       /* 219 */ XK_KP_F2,
  313.       /* 220 */ 0,
  314.       /* 221 */ 0,
  315.       /* 222 */ XK_PK_Add,
  316.       /* 223 */ 0,
  317.       /* 224 */ XK_Shift_L,
  318.       /* 225 */ XK_Shift_R,
  319.       /* 226 */ XK_Caps_Lock,
  320.       /* 227 */ XK_Control_L,
  321.       /* 228 */ XK_Alt_L,
  322.       /* 229 */ XK_Alt_R,
  323.       /* 230 */ XK_Meta_L,
  324.       /* 231 */ XK_Meta_R,
  325.       /* 232 */ 0,
  326.       /* 233 */ 0,
  327.       /* 234 */ 0,
  328.       /* 235 */ 0,
  329.       /* 236 */ 0,
  330.       /* 237 */ 0,
  331.       /* 238 */ 0,
  332.       /* 239 */ 0,
  333.       /* 240 */ 0,
  334.       /* 241 */ 0,
  335.       /* 242 */ 0,
  336.       /* 243 */ 0,
  337.       /* 244 */ 0,
  338.       /* 245 */ 0,
  339.       /* 246 */ 0,
  340.       /* 247 */ 0,
  341.       /* 248 */ 0,
  342.       /* 249 */ 0,
  343.       /* 250 */ 0,
  344.       /* 251 */ 0,
  345.       /* 252 */ 0,
  346.       /* 253 */ 0,
  347.       /* 254 */ 0,
  348.       /* 255 */ XK_Delete,
  349. };
  350. */
  351.  
  352. long Xevent_to_mask[LASTEvent] = {
  353.     0,                        /* no event 0 */
  354.     0,                        /* no event 1 */
  355.     KeyPressMask,                    /* KeyPress */
  356.     KeyReleaseMask,                    /* KeyRelease */
  357.     ButtonPressMask,                /* ButtonPress */
  358.     ButtonReleaseMask,                /* ButtonRelease */
  359.     PointerMotionMask|PointerMotionHintMask|Button1MotionMask|
  360.         Button2MotionMask|Button3MotionMask|Button4MotionMask|
  361.         Button5MotionMask|ButtonMotionMask,    /* MotionNotify */
  362.     EnterWindowMask,                /* EnterNotify */
  363.     LeaveWindowMask,                /* LeaveNotify */
  364.     FocusChangeMask,                /* FocusIn */
  365.     FocusChangeMask,                /* FocusOut */
  366.     KeymapStateMask,                /* KeymapNotify */
  367.     ExposureMask,                    /* Expose */
  368.     ExposureMask,                    /* GraphicsExpose */
  369.     ExposureMask,                    /* NoExpose */
  370.     VisibilityChangeMask,                /* VisibilityNotify */
  371.     SubstructureNotifyMask,                /* CreateNotify */
  372.     StructureNotifyMask|SubstructureNotifyMask,    /* DestroyNotify */
  373.     StructureNotifyMask|SubstructureNotifyMask,    /* UnmapNotify */
  374.     StructureNotifyMask /*|SubstructureNotifyMask*/,    /* MapNotify */
  375.     SubstructureRedirectMask,            /* MapRequest */
  376.     SubstructureNotifyMask|StructureNotifyMask,    /* ReparentNotify */
  377.     StructureNotifyMask /*|SubstructureNotifyMask*/,    /* ConfigureNotify */
  378.     SubstructureRedirectMask,            /* ConfigureRequest */
  379.     SubstructureNotifyMask|StructureNotifyMask,    /* GravityNotify */
  380.     ResizeRedirectMask,                /* ResizeRequest */
  381.     SubstructureNotifyMask|StructureNotifyMask,    /* CirculateNotify */
  382.     SubstructureRedirectMask,            /* CirculateRequest */
  383.     PropertyChangeMask,                /* PropertyNotify */
  384.     0,                        /* SelectionClear */
  385.     0,                        /* SelectionRequest */
  386.     0,                        /* SelectionNotify */
  387.     ColormapChangeMask,                /* ColormapNotify */
  388.     0,                        /* ClientMessage */
  389.     0,                        /* MappingNotify */
  390. };
  391.  
  392. /* funcs */
  393.  
  394. char lookup_key(char *key)
  395. {
  396.   if(strcmp(key,"space")==0) return(' ');
  397.   else if(strcmp(key,"comma")==0) return(',');
  398.   else if(strcmp(key,"greater")==0) return('>');
  399.   else if(strcmp(key,"less")==0) return('<');
  400.   return(0);
  401. }
  402.  
  403. void amiga_get_event(void)
  404. {
  405.   struct IntuiMessage *winmsg=NULL;
  406.   int i;
  407.  
  408.   EG.nPeeked=0;
  409.   for(i=0;i<X11NumDrawablesWindows;i++){
  410.     EG.X11eventwin=X11DrawablesWindows[i];
  411.     if(EG.X11eventwin&&X11ActualWindows[i].mapped){
  412.       EG.nEventDrawable=X11DrawablesWindowsInvMap[i];
  413.       winmsg = (struct IntuiMessage *)GetMsg(EG.X11eventwin->UserPort);
  414.       if(winmsg) break;
  415.     }
  416.   }
  417.  
  418.   if(winmsg){
  419.     EG.nMouseX=winmsg->MouseX;
  420.     EG.nBorderX=EG.X11eventwin->BorderLeft;
  421.     EG.nMouseY=winmsg->MouseY;
  422.     EG.nBorderY=EG.X11eventwin->BorderTop;
  423.     EG.nClass=winmsg->Class;
  424.     EG.nCode=winmsg->Code;
  425.     EG.nQual=winmsg->Qualifier&255;
  426.     EG.nButtonMask=(EG.nButtonMask&(0xff00))|EG.nQual;
  427.     EG.nTime=(unsigned long)(winmsg->Seconds*1000+winmsg->Micros/1000);
  428.     ALookupKey(winmsg);
  429.     ReplyMsg((struct Message *)winmsg);
  430.     EG.bHaveWinMsg=1;
  431.   }else{ /*EG.nClass=EG.nCode=EG.nQual=0;*/EG.bHaveWinMsg=0;}
  432. }
  433.  
  434. X11NewInternalXEvent(XEvent *event,int size){
  435.   _InternalXEvent *new=(_InternalXEvent *)malloc(sizeof(_InternalXEvent));
  436.   if(!new) X11resource_exit(EVENTS1);
  437.   List_AddEntry(pMemoryList,(void*)new);
  438.   new->xev=malloc(size);
  439.   List_AddEntry(pMemoryList,(void*)new->xev);
  440.   if(!new->xev) X11resource_exit(EVENTS2);
  441.   memcpy(new->xev,event,size);
  442.   new->next=NULL;
  443.   new->size=size;
  444.   if(EG.X11InternalEvents==NULL) EG.X11InternalEvents=new;
  445.   else EG.X11InternalEventsLast->next=new;
  446.   EG.X11InternalEventsLast=new;
  447. }
  448.  
  449. void X11init_events(void)
  450. {
  451.   EG.nButtonMask=0;
  452.   EG.nPrevInside=-1;
  453.   EG.nPeeked=0;
  454.   EG.bDontWait=0;
  455.   EG.bButtonSwitch=0;
  456.   EG.bHaveWinMsg=0;
  457.   EG.X11InternalEvents=NULL;
  458.   EG.X11eventwin=NULL;
  459.   EG.fwindowsig=0;
  460. }
  461.  
  462. int X11NextInternalXEvent(XEvent *event){
  463.   if(EG.X11InternalEvents!=NULL){
  464.     _InternalXEvent *old=EG.X11InternalEvents;
  465.  
  466.     EG.X11InternalEvents=EG.X11InternalEvents->next;
  467.     memcpy(event,old->xev,old->size);
  468.     List_RemoveEntry(pMemoryList,(void*)old->xev);
  469.     List_RemoveEntry(pMemoryList,(void*)old);
  470.     return(1);
  471.   }
  472.   return 0;
  473. }
  474.  
  475. /*
  476. int X11NextInternalXEvent(XEvent *event){
  477.   if(EG.X11InternalEvents!=NULL){
  478.     static _InternalXEvent *old=NULL,*prev=NULL;
  479.  
  480.     if(old==NULL){
  481.       old=EG.X11InternalEvents;
  482.       prev=NULL;
  483.     }
  484.     
  485.     while(old!=NULL){
  486.       int win=old->xev->xclient.window;
  487.       if(win==EG.nEventDrawable||
  488.      (X11Drawables[win]==X11SUBWINDOW&&
  489.       X11DrawablesChildren[X11DrawablesSubWindows[X11DrawablesMap[win]]].parent==EG.nEventDrawable)||EG.bX11ReleaseAll)
  490. /*      if(old->xev->type==ClientMessage||
  491.      old->xev->type!=ClientMessage)*/{
  492. /*    if(old->xev->type==ClientMessage) printf("clientmessage released! to %d\n",EG.nEventDrawable);*/
  493.     memcpy(event,old->xev,old->size);
  494. /*
  495.     printf("releasing internal event to %d: ",event->xany.window);
  496.     switch(event->type){
  497.     case Expose: printf("expose\n"); break;
  498.     case MapNotify: printf("MapNotify\n"); break;
  499.     case UnmapNotify: printf("UnmapNotify\n"); break;
  500.     case VisibilityNotify: printf("VisibilityNotify\n"); break;
  501.     }
  502. */
  503.     if(prev==NULL) EG.X11InternalEvents=EG.X11InternalEvents->next;
  504.     else{
  505.       if(prev->next==EG.X11InternalEventsLast) EG.X11InternalEventsLast=prev;
  506.       prev->next=old->next;
  507.     }
  508.     List_RemoveEntry(pMemoryList,(void*)old->xev);
  509.     List_RemoveEntry(pMemoryList,(void*)old);
  510.     prev=old;
  511.     old=old->next;
  512.     return(1);
  513.       }
  514.       prev=old;
  515.       old=old->next;
  516.       EG.bX11SkippedClient=1;
  517.     }
  518.   }
  519.   return(0);
  520. }
  521. */
  522. void X11exit_events(void){
  523.   XEvent event;
  524.   EG.bX11ReleaseAll=1;
  525.   while(EG.X11InternalEvents) X11NextInternalXEvent(&event);
  526. }
  527.  
  528. void X11AddExpose(Drawable win,struct Window *ewin){
  529.   XEvent ievent;
  530.   int i;
  531.   for(i=0;i<X11NumDrawables;i++){
  532.     if((X11Drawables[i]==X11SUBWINDOW&&
  533.     X11DrawablesChildren[X11DrawablesSubWindows[X11DrawablesMap[i]]].parent==win/*&&
  534.     X11DrawablesChildren[X11DrawablesSubWindows[X11DrawablesMap[i]]].mapped*/)||
  535.        i==win){
  536.       ievent.type=Expose; ievent.xexpose.count=0;
  537. /*
  538.       printf("Adding expose event to %d\n",i);
  539. */
  540.       ievent.xexpose.window=ievent.xany.window=i;
  541. /*      printf("adding expose event (%d) to %d\n",Expose,i);*/
  542.       if(i==win && ewin &&X11Drawables[i]==X11WINDOW){
  543.     ievent.xexpose.x=ewin->LeftEdge; ievent.xexpose.y=ewin->TopEdge;
  544.     ievent.xexpose.width=ewin->Width-(ewin->BorderLeft+ewin->BorderRight);
  545.     ievent.xexpose.height=ewin->Height-(ewin->BorderTop+ewin->BorderBottom);
  546.       } else if (i==win && X11Drawables[i]==X11SUBWINDOW) {
  547.     ievent.xexpose.width=X11DrawablesChildren[X11DrawablesSubWindows[X11DrawablesMap[i]]].width;
  548.     ievent.xexpose.height=X11DrawablesChildren[X11DrawablesSubWindows[X11DrawablesMap[i]]].height;
  549.     ievent.xexpose.x=X11DrawablesChildren[X11DrawablesSubWindows[X11DrawablesMap[i]]].x;
  550.     ievent.xexpose.y=X11DrawablesChildren[X11DrawablesSubWindows[X11DrawablesMap[i]]].y;
  551.       }
  552.       X11NewInternalXEvent(&ievent,sizeof(XExposeEvent));
  553.     }
  554.   }
  555. }
  556.  
  557. void X11AddConfigure(Drawable win,struct Window *ewin){
  558.   XEvent ievent;
  559.  
  560.   ievent.type=ConfigureNotify;
  561.   ievent.xconfigure.window=ievent.xany.window=win;
  562.   if(ewin){
  563.     ievent.xconfigure.x=/*ewin->LeftEdge+*/ewin->BorderLeft;
  564.     ievent.xconfigure.y=/*ewin->TopEdge+*/ewin->BorderTop;
  565.     ievent.xconfigure.width=ewin->Width-(ewin->BorderLeft+ewin->BorderRight);
  566.     ievent.xconfigure.height=ewin->Height-(ewin->BorderTop+ewin->BorderBottom);
  567.   } else {
  568.     ievent.xconfigure.width=X11DrawablesChildren[X11DrawablesSubWindows[X11DrawablesMap[win]]].width;
  569.     ievent.xconfigure.height=X11DrawablesChildren[X11DrawablesSubWindows[X11DrawablesMap[win]]].height;
  570.     ievent.xconfigure.x=X11DrawablesChildren[X11DrawablesSubWindows[X11DrawablesMap[win]]].x;
  571.     ievent.xconfigure.y=X11DrawablesChildren[X11DrawablesSubWindows[X11DrawablesMap[win]]].y;
  572.   }
  573.   X11NewInternalXEvent(&ievent,sizeof(XConfigureEvent));
  574. }
  575.  
  576. void X11AddInternalEvent(Window win,int type,int size){
  577.   XEvent ievent;
  578.   ievent.type=type;
  579.   ievent.xany.window=win;
  580.   X11NewInternalXEvent(&ievent,size);
  581. }
  582.  
  583. void X11AddInternal(Window win,int type,int size){
  584.   XEvent ievent;
  585.   int i;
  586.   for(i=0;i<X11NumDrawables;i++){
  587.     if((X11Drawables[i]==X11SUBWINDOW&&
  588.     X11DrawablesChildren[X11DrawablesSubWindows[X11DrawablesMap[i]]].parent==win)||
  589.        i==win){
  590. /*
  591.       printf("adding internal event to %d :",i);
  592.       switch(type){
  593.       case MapNotify: printf("MapNotify\n"); break;
  594.       case UnmapNotify: printf("UnmapNotify\n"); break;
  595.       case VisibilityNotify: printf("VisibilityNotify\n"); break;
  596.       }
  597. */
  598.       ievent.type=type;
  599.       ievent.xany.window=i;
  600.       switch(type){
  601.       case UnmapNotify: ievent.xunmap.window=i; break;
  602.       case MapNotify: ievent.xmap.window=i; break;
  603.       }
  604.       X11NewInternalXEvent(&ievent,size);
  605.     }
  606.   }
  607. }
  608.  
  609. XNextEvent(display, event_return)
  610.      Display *display;
  611.      XEvent *event_return;
  612. {
  613. /*  int gotone=EG.bHaveWinMsg;*/
  614. #ifdef DEBUGXEMUL_ENTRY
  615.   printf("(events)XNextEvent [%d]\n",event_return->xbutton.subwindow);
  616. #endif 
  617.   if(X11NextInternalXEvent(event_return)){
  618.     EG.bX11SkippedClient=0;
  619. /*    printf("returning internal ");
  620.     if(event_return->type==Expose) printf("expose event to %d\n",event_return->xany.window);
  621.     else
  622.       if(event_return->type==MapNotify) printf("mapping event to %d\n",event_return->xany.window);
  623.       else printf("whats this? %d\n",event_return->type);*/
  624.     return;
  625.   }
  626.  
  627.   if(!EG.nPeeked) XPending(display);
  628.  
  629.   event_return->type=0;
  630.   event_return->xany.window=0;
  631.  
  632.   if(EG.bDontWait){
  633.     if(!EG.nPeeked)XPeekEvent(display,event_return);
  634.   }else
  635.     if(!EG.bHaveWinMsg)
  636.       if(EG.fwindowsig){
  637.     while(!XPending(display)){
  638.       Wait(EG.fwindowsig);
  639.     }
  640.       }
  641.   if(EG.fwindowsig){
  642.     if(!EG.nPeeked)XPeekEvent(display,event_return);
  643.   }else return(0);
  644.   EG.nPeeked=0;
  645.   EG.bDontWait=0;
  646.   return(0);
  647. }
  648.  
  649. int XPending(Display *display){
  650. #ifdef DEBUGXEMUL_ENTRY
  651.   printf("(events)XPending\n");
  652. #endif
  653.   if(EG.X11InternalEvents!=NULL&&!EG.bX11SkippedClient){
  654.     return(1);
  655.   }
  656.   if(X11NumDrawablesWindows){
  657.     if(!EG.bHaveWinMsg) amiga_get_event();
  658.     if(EG.bHaveWinMsg) return(1);
  659.     else return(0);
  660.   }else return(0);
  661.   return (1);
  662. }
  663.  
  664. XPeekEvent(Display *display, XEvent *event){
  665. #ifdef DEBUGXEMUL_ENTRY
  666.   printf("(events)XPeekEvent\n");
  667. #endif
  668.   EG.nPeeked=1;
  669.   event->type=0;
  670.   if(!EG.fwindowsig) return(0);
  671.   return(get_intuievent(event));
  672. }
  673.  
  674. XSelectInput(display, win, event_mask)
  675.      Display *display;
  676.      Window win;
  677.      long event_mask;
  678. {
  679. #ifdef DEBUGXEMUL_ENTRY
  680.   printf("(events)XSelectInput %d mask [%x]\n",win,event_mask);
  681. #endif
  682.   X11DrawablesMask[win]=event_mask;
  683. /*  EG.nEventDrawable=win;*/
  684.   return(0);
  685. }
  686.  
  687. XChangeWindowAttributes(display, w, valuemask, attributes)
  688.      Display *display;
  689.      Window w;
  690.      unsigned long valuemask;
  691.      XSetWindowAttributes *attributes;
  692. {/* File 'xmgr.o'*/
  693. #ifdef DEBUGXEMUL_ENTRY
  694.   printf("XChangeWindowAttributes %d mask %d\n",w,valuemask);
  695. #endif
  696.   if(valuemask&CWEventMask){
  697.     XSelectInput(display,w,(long)attributes->event_mask);
  698.   }
  699.   if(valuemask&CWColormap){
  700.     XSetWindowColormap(display,w,attributes->colormap);
  701.   }
  702.   if(valuemask&CWCursor)
  703.     XDefineCursor(display,w,attributes->cursor);
  704.   return(0);
  705. }
  706.  
  707. XSetStandardProperties(display, w, window_name, icon_name,
  708.                icon_pixmap, argv, argc, hints)
  709.      Display *display;
  710.      Window w;
  711.      char *window_name;
  712.      char *icon_name;
  713.      Pixmap icon_pixmap;
  714.      char **argv;
  715.      int argc;
  716.      XSizeHints *hints;
  717. {/*  File 'grafikk.o'*/
  718. #ifdef DEBUGXEMUL_ENTRY
  719.   printf("(events)XSetStandardProperties %d\n",w);
  720. #endif
  721.   if(X11Drawables[w]!=X11WINDOW) return; /* not window */
  722.   X11ActualWindows[X11DrawablesMap[w]].name=window_name;
  723.   return(0);
  724. }
  725.  
  726. int handle_buttons(XEvent *event,int code){
  727.   switch(code){
  728.   case SELECTDOWN:
  729.     event->xbutton.button=Button1; EG.nButtonMask|=Button1Mask; break;
  730.   case SELECTUP:
  731.     event->xbutton.button=Button1; EG.nButtonMask&=(0xFFFF-Button1Mask); break;
  732.   case MENUDOWN:
  733.     event->xbutton.button=Button3; EG.nButtonMask|=Button3Mask; break;
  734.   case MENUUP:
  735.     event->xbutton.button=Button3; EG.nButtonMask&=(0xFFFF-Button3Mask); break;
  736.   case MIDDLEDOWN:
  737.     event->xbutton.button=Button2; EG.nButtonMask|=Button2Mask; break;
  738.   case MIDDLEUP:
  739.     event->xbutton.button=Button2; EG.nButtonMask&=(0xFFFF-Button2Mask); 
  740.     break;
  741.   default:
  742.     break;
  743.   }
  744. /*  printf("mask %x button %d (%d)\n",EG.nButtonMask,event->xbutton.button,EG.nQual);*/
  745. }
  746.  
  747. int get_intuievent(XEvent *event){
  748.   int buttoncode=0;
  749.   if(!event) return(0);
  750.   if(EG.X11InternalEvents!=NULL)
  751.     if(X11NextInternalXEvent(event)) return;
  752.  
  753. /*
  754.   printf("get_intuievent [%d]\n",EG.bHaveWinMsg);
  755. */
  756.   if(!EG.bHaveWinMsg) amiga_get_event();
  757.  
  758.   event->type=0;
  759.   event->xbutton.button=0;
  760.   if(EG.bHaveWinMsg){
  761.     int inside=0;
  762.     EG.bHaveWinMsg=0;
  763.     if(DG.bSubWins) inside=check_inside_subwindows(EG.X11eventwin,EG.nMouseX-EG.nBorderX,
  764.                            EG.nMouseY-EG.nBorderY);
  765.     event->xany.window=EG.nEventDrawable;
  766.     if(EG.nPrevInside!=inside){
  767.       XEvent ievent;
  768. /*
  769.       if(inside>DG.nNumChildren) printf("children overflow\n");
  770. */
  771.       X11DrawablesChildren[0].id=amiga_screen[0].root;
  772.       ievent.type=LeaveNotify;
  773.       if(EG.nPrevInside<=0) ievent.xany.window=EG.nEventDrawable;
  774.       else ievent.xany.window=X11DrawablesChildren[EG.nPrevInside].id;
  775.       X11NewInternalXEvent(&ievent,sizeof(XEnterWindowEvent));
  776.       ievent.type=EnterNotify;
  777.       X11NewInternalXEvent(&ievent,sizeof(XLeaveWindowEvent));
  778.       EG.nPrevInside=inside;
  779.     }
  780.     if(inside>0){
  781.       event->xany.window=X11DrawablesChildren[inside].id;
  782.     } else event->xany.window=EG.nEventDrawable;
  783. /*
  784.     printf("inside %d eventdrawable %d\n",X11DrawablesChildren[inside].id,EG.nEventDrawable);
  785. */
  786.     switch(EG.nClass){
  787.     case IDCMP_CLOSEWINDOW:
  788. #ifdef DEBUGXEMUL0
  789.       printf("(events)window is closing!\n");
  790. #endif
  791. /*      XFreeGC(displayp, gc);*/
  792.       force_exit(0);
  793.       break;
  794.     case IDCMP_VANILLAKEY:
  795.       if(inside>0) event->xkey.window=inside;
  796.       else event->xkey.window=EG.nEventDrawable;
  797.       event->xkey.state=EG.nQual;
  798.       event->xkey.keycode=EG.nCode;
  799.       if(inside>0){
  800.     event->xkey.subwindow=X11DrawablesChildren[inside].id;
  801.     event->xbutton.x-=X11DrawablesChildren[inside].x;
  802.     event->xbutton.y-=X11DrawablesChildren[inside].y;
  803.       }
  804.       event->type=KeyPress;
  805.       event->xkey.type=event->type;
  806.       break;
  807.     case IDCMP_RAWKEY:
  808. #ifdef DEBUGXEMUL0
  809. #endif
  810.       event->xkey.state=EG.nQual;
  811.       event->xkey.time=EG.nTime;
  812.       event->xkey.keycode=0;
  813.       if(EG.nCode==98||EG.nCode==100||EG.nCode==101){
  814.     EG.bButtonSwitch=1;
  815.       } else if(EG.nCode==226||EG.nCode==228||EG.nCode==229){
  816.     EG.bButtonSwitch=0;
  817.       }
  818.       if(inside>0){
  819.     event->xkey.subwindow=X11DrawablesChildren[inside].id;
  820.     event->xbutton.x-=X11DrawablesChildren[inside].x;
  821.     event->xbutton.y-=X11DrawablesChildren[inside].y;
  822.       }
  823.       if(EG.nCode<128) event->type=KeyPress;
  824.       else event->type=KeyRelease;
  825.       event->xkey.type=event->type;
  826.  
  827.       if(EG.nCode==97||EG.nCode==225||EG.nCode==96||EG.nCode==224){
  828.     break; /*shift*/
  829.       }
  830.       if(EG.nCode==101||EG.nCode==229||EG.nCode==100||EG.nCode==228){
  831.     break; /* alt */
  832.       }
  833.       if(EG.nCode==99||EG.nCode==227){
  834.     break; /*ctrl */
  835.       }
  836.       if(EG.nCode==103||EG.nCode==230||EG.nCode==102||EG.nCode==231){
  837.     break; /* amiga */
  838.       }
  839.       if(EG.nCode==98||EG.nCode==226){
  840.     break; /* caps */
  841.       }
  842.  
  843. /*
  844.       event->xkey.keycode=EG.nCode;
  845. */
  846.       event->xkey.keycode=X11Abuffer[0];
  847.       break;
  848. /*    case IDCMP_REFRESHWINDOW:*/
  849.     case IDCMP_CHANGEWINDOW:{
  850.       extern int adjx,adjy,prevx;
  851.       event->type=ConfigureNotify;
  852.       DG.nDisplayWidth=EG.X11eventwin->Width-(EG.X11eventwin->BorderLeft+EG.X11eventwin->BorderRight);
  853.       DG.nDisplayHeight=EG.X11eventwin->Height-(EG.X11eventwin->BorderTop+EG.X11eventwin->BorderBottom);
  854.       event->xconfigure.window=EG.nEventDrawable;
  855.       event->xconfigure.width=DG.nDisplayWidth;
  856.       event->xconfigure.height=DG.nDisplayHeight;
  857.       event->xconfigure.x=/*EG.X11eventwin->LeftEdge+*/ EG.X11eventwin->BorderLeft;
  858.       event->xconfigure.y=/*EG.X11eventwin->TopEdge+*/ EG.X11eventwin->BorderTop;
  859.       {
  860.     XRectangle r;
  861.     XSetClipMask(&amigaX_display,NULL,None);
  862. /*
  863.     r.x=EG.X11eventwin->BorderLeft;
  864.     r.y=EG.X11eventwin->BorderTop;
  865. */
  866.     r.x=0;
  867.     r.y=0;
  868.     r.width=DG.nDisplayWidth;r.height=DG.nDisplayHeight;
  869.     XSetClipRectangles(&amigaX_display,NULL,0,0,&r,1,0);
  870.       }
  871. /*      {
  872.     X11userdata *Xud;
  873.     Xud=(X11userdata*)(EG.X11eventwin->UserData);
  874.     SetRast(EG.X11eventwin->RPort,Xud->background);
  875.       }*/
  876. /*      RefreshWindowFrame(EG.X11eventwin);*/
  877.       X11AddInternal(event->xany.window,MapNotify,sizeof(XMapEvent));
  878.       X11AddExpose(event->xany.window,EG.X11eventwin);
  879.     }
  880.       break;
  881.     case IDCMP_MOUSEBUTTONS:
  882. /*
  883.       printf("(events)mousebuttons! [%d] qual [%x]\n",EG.nCode,EG.nQual);
  884. */
  885.       if(EG.bButtonSwitch){
  886.     if(EG.nCode==MENUDOWN||EG.nCode==SELECTDOWN) EG.nCode=MIDDLEDOWN;
  887.     else if(EG.nCode==MENUUP||EG.nCode==SELECTUP) EG.nCode=MIDDLEUP;
  888.       }
  889.       buttoncode=EG.nCode;
  890.       handle_buttons(event,EG.nCode);
  891.       event->xbutton.x=EG.nMouseX-EG.nBorderX;
  892.       event->xbutton.y=EG.nMouseY-EG.nBorderY;
  893.       if(inside>0){
  894.     event->xbutton.subwindow=X11DrawablesChildren[inside].id;
  895.     event->xbutton.x-=X11DrawablesChildren[inside].x;
  896.     event->xbutton.y-=X11DrawablesChildren[inside].y;
  897.       }
  898.       event->xbutton.state=EG.nQual;
  899.       event->xbutton.time=EG.nTime;
  900.       {
  901.     if(EG.nCode==SELECTUP||EG.nCode==MENUUP||EG.nCode==MIDDLEUP){
  902.       event->type=ButtonRelease;
  903.     }
  904.     else{
  905.       event->type=ButtonPress;
  906.     }
  907.       }
  908.       handle_buttons(event,buttoncode);
  909.       break;
  910.     case IDCMP_MOUSEMOVE:
  911. #ifdef DEBUGXEMUL0
  912.       printf("(events)mousemove! [%d,%d]\n",EG.nMouseX-EG.nBorderX,EG.nMouseY-EG.nBorderY);
  913. #endif
  914.       event->type=MotionNotify;
  915.       event->xbutton.x=EG.nMouseX-EG.nBorderX;
  916.       event->xbutton.y=EG.nMouseY-EG.nBorderY;
  917.       event->xbutton.state=EG.nQual;
  918.       if(inside>0){
  919.     event->xbutton.subwindow=X11DrawablesChildren[inside].id;
  920.     event->xbutton.x-=X11DrawablesChildren[inside].x;
  921.     event->xbutton.y-=X11DrawablesChildren[inside].y;
  922.       }
  923.       event->xbutton.time=EG.nTime;
  924.       break;
  925.     case IDCMP_ACTIVEWINDOW:
  926. #ifdef DEBUGXEMUL0
  927.       printf("(events)active window %d !\n",EG.nEventDrawable);
  928. #endif
  929.       EG.nQual=0;
  930.       event->type=EnterNotify;
  931.       amiga_screen[0].root=EG.nEventDrawable;
  932.       break;
  933.     case IDCMP_INACTIVEWINDOW:
  934.       EG.nQual=0;
  935. #ifdef DEBUGXEMUL0
  936.       printf("(events)inactive window! %d\n",EG.nEventDrawable);
  937. #endif
  938.       event->type=LeaveNotify;
  939.       break;
  940.     default:
  941. #ifdef DEBUGXEMUL0
  942.       printf("(events)other code\n");
  943. #endif
  944.       break;
  945.     }
  946.     EG.nCode=0;
  947.     if(inside==0) inside=EG.nEventDrawable;
  948. /*    printf(" inside(%d) mask %d event %d = %d\n",inside,X11DrawablesMask[inside],Xevent_to_mask[event->type],(X11DrawablesMask[inside]&(Xevent_to_mask[event->type])));*/
  949.     if((X11DrawablesMask[event->xany.window]&(Xevent_to_mask[event->type]))!=0/*==Xevent_to_mask[event->type]*/){
  950. #ifdef DEBUGXEMUL
  951.       printf("accepted %x %x inside %d\n",event->type,X11DrawablesMask[EG.nEventDrawable],inside);
  952. #endif
  953.       return(1);
  954.     }
  955. /*
  956.     if(([0]&(Xevent_to_mask[event->type]))!=0 /*==Xevent_to_mask[event->type]*/){
  957.       event->xkey.window=amiga_screen[0].root;
  958. #ifdef DEBUGXEMUL
  959.       printf("root accepted %x %x inside %d\n",event->type,amigamask[inside],inside);
  960. #endif
  961.       return(1);
  962.     }
  963. */
  964. #ifdef DEBUGXEMUL0
  965.     printf("not accepted %x %x inside %d!\n",event->type,X11DrawablesMask[EG.nEventDrawable],inside);
  966. #endif
  967.   {
  968.     if( X11Drawables[event->xany.window]==X11SUBWINDOW ){ /* give the parent the event */
  969.       int parent=X11DrawablesChildren[X11DrawablesSubWindows[X11DrawablesMap[event->xany.window]]].parent;
  970.       if((X11DrawablesMask[parent]&(Xevent_to_mask[event->type]))!=0){
  971.     switch(EG.nClass){
  972.     case IDCMP_MOUSEBUTTONS:
  973.     case IDCMP_MOUSEMOVE:
  974.       event->xbutton.x=EG.nMouseX-EG.nBorderX;
  975.       event->xbutton.y=EG.nMouseY-EG.nBorderY;
  976.       break;
  977.     }
  978.     event->xany.window=parent;
  979.     return 1;
  980.       }
  981.     }
  982.   }
  983.     event->type=0;
  984.   }
  985.   EG.bHaveWinMsg=0;
  986.   EG.nCode=0;
  987.   return(0);
  988. }
  989.  
  990. int XLookupString(event_structure, buffer_return, bytes_buffer,
  991.           keysym_return, status_in_out)
  992.      XKeyEvent *event_structure;
  993.      char *buffer_return;
  994.      int bytes_buffer;
  995.      KeySym *keysym_return;
  996.      XComposeStatus *status_in_out;/* may not be implemented */
  997. {
  998. #ifdef DEBUGXEMUL_ENTRY
  999.   printf("(events)XLookupString [%d]\n",X11Abuffer[0]);
  1000. #endif
  1001.   if(keysym_return)*keysym_return=0;
  1002.   *buffer_return=0;
  1003.   EG.nCode=0;
  1004.  
  1005.   if(event_structure->type==KeyPress||event_structure->type==KeyRelease){
  1006.     if(!event_structure->keycode){
  1007.       X11Abuffer[0]=0;
  1008.       return 0;
  1009.     }
  1010.     if(keysym_return)*keysym_return=(XID)event_structure->keycode;
  1011.     strncpy(buffer_return,X11Abuffer,bytes_buffer);
  1012.     return 1;
  1013. /*
  1014.     if(event_structure->keycode>223&&event_structure->keycode<232){
  1015.       if(keysym_return)*keysym_return=event_structure->keycode-128;
  1016.       X11Abuffer[0]=0;
  1017.       return 0;
  1018.     }else
  1019.       if(event_structure->keycode>95&&event_structure->keycode<104){
  1020.     if(keysym_return)*keysym_return=event_structure->keycode;
  1021.     X11Abuffer[0]=0;
  1022.     return 0;
  1023.       } else
  1024.     if(event_structure->keycode>75&&event_structure->keycode<80){
  1025.       if(keysym_return){
  1026.         switch(event_structure->keycode){
  1027.         case 76:
  1028.         case 204: *keysym_return=XK_Up; break;
  1029.         case 77:
  1030.         case 205: *keysym_return=XK_Down; break;
  1031.         case 78:
  1032.         case 206: *keysym_return=XK_Right; break;
  1033.         case 79:
  1034.         case 207: *keysym_return=XK_Left; break;
  1035.         }
  1036.       }
  1037.       X11Abuffer[0]=0;
  1038.       return 0;
  1039.     } else{
  1040.       X11Abuffer[1]=0;
  1041.       if(keysym_return)*keysym_return=(XID)X11Abuffer[0];
  1042.       strncpy(buffer_return,X11Abuffer,bytes_buffer);
  1043.       X11Abuffer[0]=0;
  1044.       return 1;
  1045.     }
  1046. */
  1047.   }
  1048. }
  1049.  
  1050. void ALookupKey(struct IntuiMessage *im){
  1051.   WORD actual;
  1052.   struct InputEvent ie ={0};
  1053.   int q=im->Qualifier&255;
  1054.   if (im->Class != IDCMP_RAWKEY||!im->Code) return;
  1055. /*
  1056.   X11Abuffer[0]=0;
  1057. */
  1058.   ie.ie_Class = IECLASS_RAWKEY;
  1059.   ie.ie_SubClass = 0;
  1060.   ie.ie_Code = im->Code /*&127*/;
  1061.   if(q==1||q==2 /*||q==8 */) ie.ie_Qualifier = im->Qualifier&255;
  1062.   else {
  1063.     ie.ie_Qualifier = 0;
  1064.   }
  1065. /*
  1066.   ie.ie_Qualifier= im->Qualifier&255;
  1067. */
  1068.  
  1069. /*  printf("qualifier %d\n",ie.ie_Qualifier);*/
  1070.   if(im->IAddress){
  1071.     ie.ie_EventAddress = (APTR *) *((ULONG *)im->IAddress);
  1072.     actual = MapRawKey(&ie, X11Abuffer, BUFFERLEN, NULL);
  1073.   }
  1074. /*
  1075.   if(X11Abuffer[0]==0){
  1076.     unsigned char key;
  1077.     switch(q){
  1078.     case 1: key=XK_Shift_L&0xff; break;
  1079.     case 2: key=XK_Shift_R&0xff; break;
  1080.     case 4: key=XK_Shift_L&0xff; break;
  1081.     case 8: key=XK_Control_L&0xff; break;
  1082.     case 16: key=XK_Alt_L&0xff; break;
  1083.     case 32: key=XK_Alt_R&0xff; break;
  1084.     case 64: key=XK_Meta_L&0xff; break;
  1085.     case 128: key=XK_Meta_R&0xff; break;
  1086.     }
  1087.     X11Abuffer[0]=key;
  1088.   }
  1089. */
  1090. }
  1091.  
  1092. XRefreshKeyboardMapping(map_event)
  1093.      XMappingEvent *map_event;
  1094. {/* File 'class1.o'*/
  1095. #if (DEBUGXEMUL_ENTRY) || (DEBUGXEMUL_WARNING)
  1096.   printf("WARNING: XRefreshKeyboardMapping\n");
  1097. #endif
  1098.   return(0);
  1099. }
  1100.  
  1101. XFlush(Display *d){
  1102.   XEvent event;
  1103. #ifdef DEBUGXEMUL_ENTRY
  1104.   printf("XFlush..");
  1105. #endif
  1106.   if(X11NumDrawablesWindows)
  1107.     while(XPending(&amigaX_display)){
  1108.       get_intuievent(&event);
  1109.     }
  1110. #ifdef DEBUGXEMUL
  1111.   printf("Flushed..\n");
  1112. #endif
  1113.   return(0);
  1114. }
  1115.  
  1116.  
  1117. int XEventsQueued(display, mode)
  1118.      Display *display;
  1119.      int mode;
  1120. {/*           File 'xast.o'*/
  1121. #ifdef DEBUGXEMUL_ENTRY
  1122.   printf("XEventsQueued\n");
  1123. #endif
  1124. /*  if()
  1125.     return(XPeekEvent(&amigaX_display,&peekevent));*/
  1126.   EG.bDontWait=1;
  1127.   return(XPending(&amigaX_display));
  1128. }
  1129.  
  1130. Bool XQueryPointer(display, w, root_return, child_return,
  1131.            root_x_return, root_y_return,
  1132.            win_x_return, win_y_return, mask_return)
  1133.      Display *display;
  1134.      Window w;
  1135.      Window *root_return, *child_return;
  1136.      int *root_x_return, *root_y_return;
  1137.      int *win_x_return, *win_y_return;
  1138.      unsigned int *mask_return;
  1139.  
  1140. {
  1141.   XEvent event;
  1142.   int old;
  1143.   struct Window *win=Agetwin(w);
  1144.   prevwin=-1;
  1145. #ifdef DEBUGXEMUL_ENTRY
  1146.   printf("XQueryPointer reative to [%d] %d\n",w,EG.nEventDrawable);
  1147. #endif
  1148.   if(!win) return 0;
  1149.   if(X11Drawables[w]==X11WINDOW){
  1150.     *win_x_return=win->MouseX-win->BorderLeft;
  1151.     *win_y_return=win->MouseY-win->BorderTop;
  1152.   } else if(X11Drawables[w]==X11SUBWINDOW){
  1153.     int child=X11DrawablesSubWindows[X11DrawablesMap[w]];
  1154.     *win_x_return=win->MouseX-X11DrawablesChildren[child].x-win->BorderLeft;
  1155.     *win_y_return=win->MouseY-X11DrawablesChildren[child].y-win->BorderTop;
  1156.   }
  1157.   if(root_x_return) *root_x_return=win->MouseX-win->BorderLeft;
  1158.   if(root_y_return) *root_y_return=win->MouseY-win->BorderTop;
  1159. /*
  1160. } else {
  1161.     struct Window *win=X11DrawablesWindows[X11DrawablesMap[EG.nEventDrawable]];
  1162.     if(!win) return 0;
  1163.     *win_x_return=-win->BorderLeft+win->MouseX/*EG.nMouseX-EG.nBorderX*/;
  1164.     *win_y_return=-win->BorderTop+win->MouseY/*EG.nMouseY-EG.nBorderY*/;
  1165.     if(root_x_return) *root_x_return=/*win->LeftEdge+*/*win_x_return;
  1166.     if(root_y_return) *root_y_return=/*win->TopEdge+*/*win_y_return;
  1167.   }
  1168. */
  1169.   old=EG.nEventDrawable;
  1170.   EG.nEventDrawable=w;
  1171.   if(XPending(display)){
  1172.     get_intuievent(&event);
  1173.   } else{
  1174.     if(EG.fwindowsig) Wait(EG.fwindowsig); 
  1175.     get_intuievent(&event);
  1176.   }
  1177.   *mask_return=EG.nButtonMask;
  1178.   EG.nEventDrawable=old;
  1179.   return(TRUE);
  1180. }
  1181.  
  1182.  
  1183. Bool XCheckIfEvent(display, event_return, predicate, arg)
  1184.      Display *display;
  1185.      XEvent *event_return;
  1186.      Bool (*__stdargs predicate)(Display *,XEvent*,char *data);
  1187.      char *arg;
  1188. {
  1189. #ifdef DEBUGXEMUL_ENTRY
  1190.   printf("XCheckIfEvent\n");
  1191. #endif
  1192.   if(XPending(display)){
  1193.     XNextEvent(display,event_return);
  1194.     if(predicate(display,event_return,arg)) return(1);
  1195.   }
  1196.   return(0);
  1197. }
  1198.  
  1199. XWindowEvent(display, w, event_mask, event_return)
  1200.      Display *display;
  1201.      Window w;
  1202.      long event_mask;
  1203.      XEvent *event_return;
  1204. {/*            File 'xvbutt.o' */
  1205.   long old;
  1206. #ifdef DEBUGXEMUL_ENTRY
  1207.   printf("XWindowEvent %d\n",w);
  1208. #endif
  1209.   old=X11DrawablesMask[w];
  1210.   X11DrawablesMask[w]=event_mask;
  1211.   do{
  1212.     XNextEvent(display,event_return);
  1213.   }while(!(Xevent_to_mask[event_return->type]&event_mask));
  1214.   X11DrawablesMask[w]=old;
  1215. }
  1216.  
  1217. Bool XCheckTypedEvent(display, event_type, event_return)
  1218.      Display *display;
  1219.      int event_type;
  1220.      XEvent *event_return;
  1221. {
  1222. #ifdef DEBUGXEMUL_ENTRY
  1223.   printf("XCheckTypedEvent\n");
  1224. #endif
  1225.   do{
  1226.     XNextEvent(display,event_return);
  1227.   }while(event_return->type!=event_type && XPending(display));
  1228. }
  1229.  
  1230. int
  1231.   select(int nfds, int *readfds, int *writefds, int *exceptfds,
  1232.      struct timeval *timeout)
  1233. {/*                  File 'usleep.o'*/
  1234. #ifdef DEBUGXEMUL
  1235. #endif
  1236.   if(timeout==NULL){
  1237.     if(EG.fwindowsig) Wait(EG.fwindowsig);
  1238.   } else X11delayfor(timeout->tv_secs,timeout->tv_micro);
  1239.   return(0);
  1240. }
  1241.  
  1242. #define XK_MISCELLANY
  1243. #define XK_LATIN1
  1244. #include <X11/keysymdef.h>
  1245.  
  1246. char X11str[10];
  1247.  
  1248. KeySym XLookupKeysym(event, index)
  1249.      XKeyEvent *event;
  1250.      int index;
  1251. {/*           File 'w_canvas.o'*/
  1252.   int retval=0;
  1253. #ifdef DEBUGXEMUL_ENTRY
  1254.   printf("XLookupKeysym\n");
  1255. #endif
  1256.   switch(event->keycode){
  1257.   case 227: case 99: retval=XK_Control_L; break;
  1258.   case 225: case 97: retval=XK_Shift_R; break;
  1259.   case 224: case 96: retval=XK_Shift_L; break;
  1260.   case 101: case 229: retval=XK_Alt_R; break;
  1261.   case 100: case 228: retval=XK_Alt_L; break;
  1262.   case 103: case 231: retval=XK_Meta_R; break;
  1263.   case 102: case 230: retval=XK_Meta_L; break;
  1264.   case 98: case 226: retval=XK_Caps_Lock; break;
  1265.   case 76: case 204: retval=XK_Up; break;
  1266.   case 77: case 205: retval=XK_Down; break;
  1267.   case 78: case 206: retval=XK_Right; break;
  1268.   case 79: case 207: retval=XK_Left; break;
  1269.   case 68: case 196: retval=XK_Return; break;
  1270.   case 69: case 197: retval=XK_Escape; break;
  1271.   case 61: case 189: retval=XK_Home; break;
  1272.   case 65: case 193: retval=XK_BackSpace; break;
  1273.   case 70: case 198: retval=XK_Delete; break;
  1274.   case 57: case 185: retval=XK_period; break;
  1275.   case 58: case 186: retval=XK_slash; break;
  1276.   }
  1277.   if(!retval)
  1278.   {
  1279.     KeySym keysym;
  1280.     XComposeStatus status;
  1281.     XLookupString(event,X11str,4,&keysym, &status);
  1282.     strcpy(X11Abuffer,X11str);
  1283.     retval=event->keycode;
  1284.   }else X11str[0]=retval;
  1285.   return((KeySym)retval);
  1286. }
  1287.  
  1288. char *XKeysymToString(keysym)
  1289.      KeySym keysym;
  1290. {
  1291.   switch(keysym){
  1292.   case XK_Return: strcpy(X11str,"Return"); break;
  1293.   case XK_Left: strcpy(X11str,"Left"); break;
  1294.   case XK_Right: strcpy(X11str,"Right"); break;
  1295.   case XK_Up: strcpy(X11str,"Up"); break;
  1296.   case XK_Down: strcpy(X11str,"Down"); break;
  1297.   case XK_Delete: strcpy(X11str,"Delete"); break;
  1298.   case XK_BackSpace: strcpy(X11str,"BackSpace"); break;
  1299.   case XK_Escape: strcpy(X11str,"Escape"); break;
  1300.   case XK_period: strcpy(X11str,"period"); break;
  1301.   case XK_slash: strcpy(X11str,"slash"); break;
  1302.   }
  1303.   return(X11str);
  1304. }
  1305.  
  1306. Bool XCheckWindowEvent(display, w, event_mask, event_return)
  1307.      Display *display;
  1308.      Window w;
  1309.      long event_mask;
  1310.      XEvent *event_return;
  1311. {
  1312.   long old;
  1313.   int parent=X11findparent(w);
  1314. #ifdef DEBUGXEMUL_ENTRY
  1315.   printf("XCheckWindowEvent %d\n",w);
  1316. #endif
  1317.   EG.nEventDrawable=parent;
  1318.   old=X11DrawablesMask[w];
  1319.   X11DrawablesMask[w]=event_mask;
  1320.   event_return->type=0;
  1321.   if(XPending(display))
  1322.     XNextEvent(display,event_return);
  1323.   X11DrawablesMask[w]=old;
  1324.   if(Xevent_to_mask[event_return->type]&event_mask) return(1);
  1325.   return(0);
  1326. }
  1327.  
  1328. XSetInputFocus(display, focus, revert_to, time)
  1329.      Display *display;
  1330.      Window focus;
  1331.      int revert_to;
  1332.      Time time;
  1333. {/*          File 'xtb/libxtb.lib' */
  1334. #ifdef DEBUGXEMUL_ENTRY
  1335.   printf("XSetInputFocus %d\n",focus);
  1336. #endif
  1337.   if(X11Drawables[focus]==X11WINDOW){
  1338.     ActivateWindow(X11DrawablesWindows[X11DrawablesMap[focus]]);
  1339.     EG.nEventDrawable=focus;
  1340.   }
  1341.   return(0);
  1342. }
  1343.  
  1344. int XGrabPointer(display, grab_window, owner_events,
  1345.          event_mask, pointer_mode, keyboard_mode, confine_to, cursor, time)
  1346.      Display *display;
  1347.      Window grab_window;
  1348.      Bool owner_events;
  1349.      unsigned int event_mask;
  1350.      int pointer_mode, keyboard_mode;
  1351.      Window confine_to;
  1352.      Cursor cursor;
  1353.      Time time;
  1354. {/*            File 'xvgam.o' */
  1355. #ifdef DEBUGXEMUL_ENTRY
  1356.   printf("XGrabPointer\n");
  1357. #endif
  1358.   if(cursor) XDefineCursor(display, grab_window, cursor);
  1359.   EG.GrabMask=X11DrawablesMask[grab_window];
  1360.   EG.GrabWin=grab_window;
  1361.   XSelectInput(display,grab_window,event_mask);
  1362.   return(0);
  1363. }
  1364.  
  1365. XUngrabPointer(display, time)
  1366.      Display *display;
  1367.      Time time;
  1368. {/*          File 'xvgam.o' */
  1369. #ifdef DEBUGXEMUL_ENTRY
  1370.   printf("XUngrabPointer\n");
  1371. #endif
  1372.   XUndefineCursor(display,NULL);
  1373.   X11DrawablesMask[EG.GrabWin]=EG.GrabMask;
  1374.   return(0);
  1375. }
  1376.  
  1377. XSetNormalHints(display, w, hints)
  1378.      Display *display;
  1379.      Window w;
  1380.      XSizeHints *hints;
  1381. {/*         File 'sunclock.o'*/
  1382. #ifdef DEBUGXEMUL_ENTRY
  1383.   printf("XSetNormalHints\n");
  1384. #endif
  1385.   if(X11ActualWindows[X11DrawablesMap[w]].mapped){
  1386.     XWindowChanges values;
  1387.     values.x=hints->x; 
  1388.     values.y=hints->y;
  1389.     values.width=hints->width;
  1390.     values.height=hints->height;
  1391.    
  1392.     XConfigureWindow(display,w,CWX|CWY|CWWidth|CWHeight,&values);
  1393.   }
  1394.   return(0);
  1395. }
  1396.  
  1397. XIfEvent(display, event_return, predicate, args)
  1398.      Display *display;
  1399.      XEvent *event_return;
  1400.      Bool (*__stdargs predicate)(Display *,XEvent*,char *data);
  1401.      char *args;
  1402. {/*                File 'magick/libMagick.lib' */
  1403. #ifdef DEBUGXEMUL_ENTRY
  1404.   printf("XIfEvent\n");
  1405. #endif
  1406.   while(1){
  1407.     XNextEvent(display,event_return);
  1408.     if(predicate(display,event_return,args)) break;
  1409.   }
  1410.  
  1411.   return(0);
  1412. }
  1413.  
  1414. Status XSendEvent(display, w, propagate, event_mask, event_send)
  1415.      Display *display;
  1416.      Window w;
  1417.      Bool propagate;
  1418.      long event_mask;
  1419.      XEvent *event_send;
  1420. {/*              File 'xvevent.o' */
  1421. #ifdef DEBUGXEMUL_ENTRY
  1422.   printf("XSendEvent %d %d (%d)\n",propagate,event_mask,event_send->type);
  1423. #endif
  1424.   event_send->xclient.window=w;
  1425.   X11NewInternalXEvent(event_send,sizeof(XEvent));
  1426.   return(0);
  1427. }
  1428.  
  1429. XPutBackEvent(display, event)
  1430.      Display *display;
  1431.      XEvent *event;
  1432. {/*           File 'w_canvas.o'*/
  1433. #ifdef DEBUGXEMUL_ENTRY
  1434.   printf("XPutBackEvent %d\n",event->type);
  1435. #endif
  1436.   X11NewInternalXEvent(event,sizeof(XEvent));
  1437.   return(0);
  1438. }
  1439.  
  1440. int XtGrabPointer(
  1441.     Widget          widget,
  1442.     _XtBoolean          owner_events,
  1443.     unsigned int     event_mask,
  1444.     int          pointer_mode,
  1445.     int          keyboard_mode,
  1446.     Window          confine_to,
  1447.     Cursor          cursor,
  1448.     Time          t
  1449. ){/*           File 'windlib.o' */
  1450. #if (DEBUGXEMUL_ENTRY) || (DEBUGXEMUL_WARNING)
  1451.   printf("WARNING: XtGrabPointer\n");
  1452. #endif
  1453.   return(0);
  1454. }
  1455.  
  1456. int XtGrabKeyboard(
  1457.     Widget         widget,
  1458.     _XtBoolean         owner_events,
  1459.     int         pointer_mode,
  1460.     int         keyboard_mode,
  1461.     Time         t
  1462. ){/*          File 'file.o' */
  1463. #if (DEBUGXEMUL_ENTRY) || (DEBUGXEMUL_WARNING)
  1464.   printf("WARNING: XtGrabKeyboard\n");
  1465. #endif
  1466.   return(0);
  1467. }
  1468.  
  1469. XWarpPointer(display, src_w, dest_w, src_x, src_y,
  1470.          src_width, src_height, dest_x, dest_y)
  1471.      Display *display;
  1472.      Window src_w, dest_w;
  1473.      int src_x, src_y;
  1474.      unsigned int src_width, src_height;
  1475.      int dest_x, dest_y;
  1476. {/*            File 'events.o'*/
  1477. #if (DEBUGXEMUL_ENTRY) || (DEBUGXEMUL_WARNING)
  1478.   printf("WARNING: XWarpPointer\n");
  1479. #endif
  1480.   return(0);
  1481. }
  1482.  
  1483. Bool XCheckMaskEvent(display, event_mask, event_return)
  1484.      Display *display;
  1485.      long event_mask;
  1486.      XEvent *event_return;
  1487. {
  1488. #ifdef DEBUGXEMUL_ENTRY
  1489.   printf("XCheckMaskEvent\n");
  1490. #endif
  1491.  
  1492.   if(XPending(display)){
  1493.     XPeekEvent(display,event_return);
  1494.     if(Xevent_to_mask[event_return->type] & event_mask) return 1;
  1495.   }
  1496.   return(0);
  1497. }
  1498.  
  1499. XPeekIfEvent(display, event_return, predicate, arg)
  1500.      Display *display;
  1501.      XEvent *event_return;
  1502.      Bool (*__stdargs predicate)(Display *,XEvent*,char *data);
  1503.      XPointer arg;
  1504. {
  1505. #ifdef DEBUGXEMUL_ENTRY
  1506.   printf("XPeekIfEvent\n");
  1507. #endif
  1508.   EG.bSkipInternal=1;
  1509.   do{
  1510.     XNextEvent(display,event_return);
  1511.     if( !predicate(display,event_return,arg) ) XPutBackEvent(display,event_return);
  1512.   }while( !predicate(display,event_return,arg) && XPending(display) );
  1513.   EG.bSkipInternal=0;
  1514.   if( !predicate(display,event_return,arg) ){
  1515.     XFlush( display );
  1516.     do{
  1517.       XNextEvent(display,event_return);
  1518.     }while( !predicate(display,event_return,arg) );
  1519.   }
  1520. }
  1521.  
  1522. #ifndef XMUIAPP
  1523. XSizeHints *XAllocSizeHints(){
  1524.   void *data=calloc(sizeof(XSizeHints),1);
  1525.   List_AddEntry(pMemoryList,(void*)data);
  1526.   return data;
  1527. }
  1528.  
  1529. XClassHint *XAllocClassHint(){
  1530.   void *data=calloc(sizeof(XClassHint),1);
  1531.   List_AddEntry(pMemoryList,(void*)data);
  1532.   return data;
  1533. }
  1534. #endif
  1535.  
  1536. XFree(data)
  1537.      void *data;
  1538. {
  1539.   List_RemoveEntry(pMemoryList,(void*)data);
  1540.   return(0);
  1541. }
  1542.  
  1543. Bool XCheckTypedWindowEvent(display, w, event_type, event_return)
  1544.      Display *display;
  1545.      Window w;
  1546.      int event_type;
  1547.      XEvent *event_return;
  1548. {/*  File 'xvevent.o' */
  1549. #if (DEBUGXEMUL_ENTRY)
  1550.   printf("XCheckTypedWindowEvent\n");
  1551. #endif
  1552.   while (XPending(display)){
  1553.     XNextEvent(display,event_return);
  1554.     if( event_return->type==event_type && event_return->xany.window==w  ) return 1;
  1555.   }
  1556.   return(0);
  1557. }
  1558.